package xyz.hujf.tool.autoclass;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.LongAdder;

/**
 * @author Hujf
 * @title: LongAdderTest
 * @date 2021-04-27 15:21
 * @description:
 *
 * 使用 LongAdder 时，则是在内部维护多个 Ce ll 变量，每个 Cell 里面
 * 有一个初始值为 0 的 long 型变量，这样，在同等并发量的情况下，争夺单个变量更新操
 * 作的线程量会减少，这变相地减少了 争夺共享资源的并发量。另 外，多个线程在争夺同一
 * 个 Cell 原子变量时如果失败了 ， 它并不是在当前 Cell 变量上一直自旋 CAS 重试，而是尝
 * 试在其他 Cell 的变量上进行 CAS 尝试 ，这个改变增加了当前线程重试 CAS 成功的可能性 。
 * 最后，在获取 LongAdder 当前值时， 是把所有 Cell 变量的 value 值累加后再加上 base 返回的 。
 *
 */
public class LongAdderTest {

    private static int num = 0;
    private static CountDownLatch count = new CountDownLatch(10);

    public static void main(String[] args) throws InterruptedException {
        HashMap<Integer, Integer> map = new HashMap<>(8);
        for (int i = 1; i <= 7; i++) {
            int sevenSlot = i * 8 + 7;
            map.put(sevenSlot, sevenSlot);
        }


        AtomicInteger atomicInteger = new AtomicInteger();
        LongAdder  longAdder = new LongAdder();
        for (int i = 0; i < 10; i++) {
            new Thread(() -> {
                for (int j = 0; j < 1000; j++) {
                    inceament();
                    atomicInteger.getAndIncrement();
                    longAdder.increment();
                }
                count.countDown();
            }).start();
        }
        count.await();
        System.out.println(num);
        System.out.println("atomicInteger.intValue() = " + atomicInteger.intValue());
        System.out.println("longAdder.intValue() = " + longAdder.intValue());
    }

    private synchronized static void inceament() {
        num++;
    }
}
